﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<assert.h>
using namespace std;
struct Point
{
	int _x;
	int _y;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

//int main()
//{
//	Point p = {1,2};//对结构体初始化
//	int a[] = { 1,2,3,4,5 };//对数组初始化
//	Date d1 = { 2025, 1, 1 };
//	// 这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象
//	const Date& d2 = { 2024, 7, 25 };
//	// 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}
//	Date d3 = { 2025 };
//	Date d4 = 2025;
//	return 0;
//}

namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str)-构造" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		void swap(string& ss)
		{
			::swap(_str, ss._str);
			::swap(_size, ss._size);
			::swap(_capacity, ss._capacity);
		}

		// 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			// 转移掠夺你的资源
			swap(s);
		}

		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}

		~string()
		{
			//cout << "~string() -- 析构" << endl;
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				if (_str)
				{
					strcpy(tmp, _str);
					delete[] _str;
				}
				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
					2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}
namespace bit
{
	string addStrings(string num1, string num2)
	{
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		cout << "******************************" << endl;
		return str;
	}
}

	/*int main()
	{
		bit::string ret = bit::addStrings("11111", "22222");
		cout << ret.c_str() << endl;
		return 0;
	}*/
	//// 场景2
	//int main()
	//{
	//	bit::string ret;
	//	ret = bit::addStrings("11111", "2222");
	//	cout << ret.c_str() << endl;
	//	return 0;
	//}
//
//// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤
//template<class T>
//void f1(T& x)
//{}
//// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤
//template<class T>
//void f2(T&& x)
//{}
//int main()
//{
//	int n = 0;
//	lref& r1 = n; // r1 的类型是 int&
//	lref&& r2 = n; // r2 的类型是 int&
//	rref& r3 = n; // r3 的类型是 int&
//	rref&& r4 = 1; // r4 的类型是 int&&
//	 //没有折叠->实例化为void f1(int& x)
//	f1<int>(n);
//	f1<int>(0); // 报错
//
//
//	 //折叠->实例化为void f1(int& x)
//
//	f1<int&>(n);
//	f1<int&>(0); // 报错
//	 //折叠->实例化为void f1(int& x)
//	f1<int&&>(n);
//	f1<int&&>(0); // 报错
//
//	return 0;
//}

//
//int main()
//{
//	int a = 10; // a 是左值，它有明确的内存地址，可以被赋值和取地址
//	int* ptr = &a; // 可以取 a 的地址
//	a = 20; // 可以对 a 进行赋值操作
//	return 0;
//}

//#include <iostream>
//#include <utility>
//class BigObject {
//private:
//	int* data;
//	size_t size;
//public:
//	// 构造函数，动态分配内存
//	BigObject(size_t s) : size(s) {
//		data = new int[size];
//		for (size_t i = 0; i < size; ++i) {
//			data[i] = i;
//		}
//	}
//	// 拷贝构造函数，进行深拷贝
//	BigObject(const BigObject& other) 
//		: size(other.size) {
//		data = new int[size];
//		for (size_t i = 0; i < size; ++i) {
//			data[i] = other.data[i];
//		}
//	  cout << "Copy constructor called" << endl;
//	}
//
//	// 移动构造函数，转移资源所有权
//	BigObject(BigObject&& other) noexcept 
//		: data(other.data)
//		, size(other.size) 
//	{
//		other.data = nullptr;
//		other.size = 0;
//		cout << "Move constructor called" << endl;
//	}
//
//	// 析构函数，释放动态分配的内存
//	~BigObject() {
//		delete[] data;
//	}
//};
//
//int main() {
//	BigObject obj1(1000);
//	// 调用移动构造函数
//	BigObject obj2(std::move(obj1));
//	return 0;
//}

#include <iostream>
#include <utility>

class MyString {
private:
	char* data;
	size_t length;

public:
	// 构造函数
	MyString(const char* str = "") {
		length = strlen(str);
		data = new char[length + 1];
		strcpy(data, str);
	}

	// 移动赋值运算符
	MyString& operator=(MyString&& other) noexcept {
		if (this != &other) {
			delete[] data;
			data = other.data;
			length = other.length;
			other.data = nullptr;
			other.length = 0;
		}
		return *this;
	}

	// 析构函数
	~MyString() {
		delete[] data;
	}

	// 打印字符串
	void print() const {
		cout << data << endl;
	}
};
//
//int main() {
//	MyString str1("Hello");
//	MyString str2("World");
//	// 使用移动赋值运算符将 str2 的资源转移到 str1
//	str1 = std::move(str2);
//	str1.print();
//	return 0;
//}



//// 用于接收左值引用的函数
//template<typename T>
//void fun1(T& value) {
//	cout << value << endl;
//}
//
//// 用于接收右值引用的函数
//template<typename T>
//void fun2(T&& value) {
//	cout << value << endl;
//}
//
// //实现完美转发的函数模板
//template<typename T>
//void fun3(T&& arg) {
//	cout << value << endl;
//}
//
//int main() {
//	int num = 42;
//	fun1(num);
//	fun2(20);
//
//	fun3(20);
//	fun3(num);
//	return 0;
//}

//#include <iostream>
//#include <utility>
//
//void process(int& val) {
//	std::cout << "Lvalue: " << val << std::endl;
//}
//
//void process(int&& val) {
//	std::cout << "Rvalue: " << val << std::endl;
//}
//
//template<typename T>
//void forwardValue(T&& arg) {
//	process(forward<T>(arg));
//}
//
//int main() {
//	int num = 10;
//	forwardValue(num); // 传递左值
//	forwardValue(20);  // 传递右值
//	return 0;
//}
//
//template <class ...Args>
//void Print(Args&&... args)
//{
//	cout << sizeof...(args) << endl;
//}
//int main()
//{
//	double x = 2.2;
//	Print(); // 包里有0个参数
//	Print(1); // 包里有1个参数
//	Print(1, string("xxxxx")); // 包里有2个参数
//	Print(1.1, string("xxxxx"), x); // 包里有3个参数
//	return 0;
////}
//
//void ShowList()
//{
//	// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数
//	cout << endl;
//}
//template <class T, class ...Args>
//void ShowList(T x, Args... args)
//{
//	cout << x << " ";
//	// args是N个参数的参数包
//	// 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包
//	ShowList(args...);
//}
//// 编译时递归推导解析参数
//template <class ...Args>
//void Print(Args... args)
//{
//	ShowList(args...);
//}
//int main()
//{
//	Print();
//	Print(1);
//	Print(1, string("xxxxx"));
//	Print(1, string("xxxxx"), 2.2);
//	return 0;
//}

//int main()
//{
//	 一个简单的lambda表达式
//	auto add1 = [](int x, int y)->int {return x + y; };
//	cout << add1(1, 2) << endl;
//	 1、捕捉为空也不能省略
//	 2、参数为空可以省略
//	 3、返回值可以省略，可以通过返回对象⾃动推导
//	 4、函数体不能省略
//	auto func1 = []
//		{
//			cout << "hello bit" << endl;
//			return 0;
//		};
//	func1();
//	int a = 0, b = 1;
//	auto swap1 = [](int& x, int& y)
//		{
//			int tmp = x;
//			x = y;
//			y = tmp;
//		};
//	swap1(a, b);
//	cout << a << ":" << b << endl;
//	return 0;
//}
//
//#include<algorithm>
//struct Goods
//{
//	string _name; // 名字
//	double _price; // 价格
//	int _evaluate; // 评价
//	// ...
//	Goods(const char* str, double price, int evaluate)
//		:_name(str)
//		, _price(price)
//		, _evaluate(evaluate)
//	{}
//};
//
//struct ComparePriceLess
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price < gr._price;
//	}
//};
//struct ComparePriceGreater
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//			return gl._price > gr._price;
//	}
//};
//
//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3
//	}, { "菠萝", 1.5, 4 } };
//	// 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中
//	// 不同项的比较，相对还是比较麻烦，那么这⾥lambda就很好⽤了
//	sort(v.begin(), v.end(), ComparePriceLess());
//	sort(v.begin(), v.end(), ComparePriceGreater());
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price < g2._price;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price > g2._price;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate < g2._evaluate;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate > g2._evaluate;
//		});
//	return 0;
//}

//#include <iostream>
//#include <functional>
//
//// 普通函数
//int add(int a, int b) {
//	return a + b;
//}
//
//// 仿函数
//struct Subtract {
//	int operator()(int a, int b) {
//		return a - b;
//	}
//};
//
//int main() {
//	// 包装普通函数
//	std::function<int(int, int)> func1 = add;
//	std::cout << "Add result: " << func1(3, 2) << std::endl;
//
//	// 包装仿函数
//	Subtract sub;
//	std::function<int(int, int)> func2 = sub;
//	std::cout << "Subtract result: " << func2(3, 2) << std::endl;
//
//	// 包装Lambda表达式
//	std::function<int(int, int)> func3 = [](int a, int b) {
//		return a * b;
//		};
//	std::cout << "Multiply result: " << func3(3, 2) << std::endl;
//
//	return 0;
//}

#include<functional>
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{
	return (a - b) * 10;
}
int SubX(int a, int b, int c)
{
	return (a - b - c) * 10;
}